// #region [多主图]
/**
 * 从HTML内容中提取图片块数据（新方法：对应Python的extract_image_block_data）
 * @param doc Document对象
 * @returns 图片数据对象（键值对形式）
 */

/**
 * 从DOMParser解析后的doc对象中提取ImageBlockATF里的data数据
 * @param {Document} doc - new DOMParser()解析后得到的Document对象
 * @returns {Object|null} 提取到的data数据，失败则返回null
 */

/**
 * 合并版：一次遍历提取ImageBlockATF或colorImages图片数据（兼容CSP，无unsafe-eval）
 * @param doc 浏览器DOM Document对象
 * @returns 图片数据字典（优先ImageBlockATF，次选colorImages，失败返回空字典）
 */
function extractMergedImageData(doc: Document): Record<string, any> {
  try {
    const scriptTags = doc.querySelectorAll("script");
    let imageBlockData: Record<string, any[]> = {};
    let colorImagesData: Record<string, any> = {};

    for (const script of Array.from(scriptTags)) {
      const scriptText = script.textContent || "";
      if (!scriptText) continue;

      // --------------------------
      // 1. 优先处理ImageBlockATF数据（修复Date.now()等JS语法）
      // --------------------------
      if (
        !Object.keys(imageBlockData).length &&
        (scriptText.includes("P.when('A').register(\"ImageBlockATF\"") ||
          scriptText.includes("ImageBlockATF"))
      ) {
        const dataRegex =
          /var\s+data\s*=\s*({(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\/\*[\s\S]*?\*\/|\/\/.*|[\s\S])*?})\s*;\s*(?:return\s+data|A\.trigger|;)/s;
        const dataMatch = scriptText.match(dataRegex);

        if (dataMatch) {
          let dataObjStr = dataMatch[1];
          try {
            // 关键修复：移除或替换JSON不支持的JS语法（如Date.now()、new Date()）
            dataObjStr = dataObjStr
              // 处理函数调用：Date.now() → 替换为当前时间戳（或null）
              .replace(/Date\.now\(\)/g, Date.now().toString())
              // 处理new Date() → 替换为ISO字符串（或null）
              .replace(/new\s+Date\(\s*\)/g, `"${new Date().toISOString()}"`)
              // 处理带参数的new Date(xxx) → 保留字符串形式
              .replace(
                /new\s+Date\(([^)]+)\)/g,
                (match, p1) => `"new Date(${p1})"`
              )
              // 原有格式修复逻辑
              .replace(/,\s*([}\]])/g, "$1")
              .replace(/(?<!\\)'/g, '"')
              .replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)(\s*:)/g, '$1"$2"$3')
              .replace(/\\\\/g, "\\");

            const data = JSON.parse(dataObjStr);
            if (
              data?.colorImages?.initial &&
              Array.isArray(data.colorImages.initial)
            ) {
              imageBlockData = { initial: data.colorImages.initial };
              // console.info(
              //   `✅ 优先提取ImageBlockATF数据，共 ${imageBlockData.initial.length} 个变体`
              // );
            }
          } catch (parseErr) {
            console.error(
              `❌ ImageBlockATF解析失败: ${
                parseErr instanceof Error ? parseErr.message : String(parseErr)
              }`
            );
            console.error(`🪵 问题片段: ${dataObjStr.slice(0, 200)}...`);
          }
        }
      }

      // --------------------------
      // 2. 处理colorImages数据（逻辑不变）
      // --------------------------
      if (
        !Object.keys(imageBlockData).length &&
        !Object.keys(colorImagesData).length &&
        scriptText.includes("colorImages") &&
        scriptText.includes("jQuery.parseJSON")
      ) {
        const colorImagesPos = scriptText.indexOf('"colorImages"');
        if (colorImagesPos === -1) continue;

        const colonPos = scriptText.indexOf(":", colorImagesPos);
        if (colonPos === -1) continue;

        let pos = colonPos + 1;
        while (pos < scriptText.length && /\s/.test(scriptText[pos])) pos++;
        if (pos >= scriptText.length || scriptText[pos] !== "{") continue;

        let startPos = pos;
        let braceCount = 1;
        pos++;
        while (pos < scriptText.length && braceCount > 0) {
          if (scriptText[pos] === "{") braceCount++;
          else if (scriptText[pos] === "}") braceCount--;
          pos++;
        }

        if (braceCount === 0) {
          let colorJson = scriptText.slice(startPos, pos);
          try {
            colorJson = colorJson
              .replace(/\\''/g, "''")
              .replace(/\\'/g, "'")
              .replace(/\\"/g, '"')
              .replace(/\\\\/g, "\\");

            const rawData = JSON.parse(colorJson);
            const cleanedData: Record<string, any> = {};
            Object.entries(rawData).forEach(([key, value]) => {
              cleanedData[key.replace(/\\/g, "")] = value;
            });

            colorImagesData = cleanedData;
            // console.info(
            //   `✅ 提取colorImages数据，共 ${
            //     Object.keys(colorImagesData).length
            //   } 个变体`
            // );
          } catch (parseErr) {
            console.error(
              `❌ colorImages解析失败: ${
                parseErr instanceof Error ? parseErr.message : String(parseErr)
              }`
            );
          }
        }
      }

      if (
        Object.keys(imageBlockData).length ||
        Object.keys(colorImagesData).length
      ) {
        break;
      }
    }

    const result = Object.keys(imageBlockData).length
      ? imageBlockData
      : Object.keys(colorImagesData).length
      ? colorImagesData
      : {};

    if (Object.keys(result).length === 0) {
      console.info("⚠️ 未找到任何图片数据");
    }
    return result;
  } catch (e) {
    console.error(
      `❌ 合并提取图片数据出错: ${e instanceof Error ? e.message : String(e)}`
    );
    return {};
  }
}

/**
 * 从商品详情页提取所有高清主图URL
 * @param htmlContent HTML字符串（可选，若传入则解析为Document；否则直接使用doc参数）
 * @param doc 可选，已解析的Document对象（用于避免重复解析）
 * @returns 高清主图URL列表
 */
export function extractMainImages(doc: Document): string[] {
  // const startTime = performance.now(); // 记录开始时间
  let urls: string[] = [];

  // 优先使用新的ImageBlockATF数据提取方法
  const colorImagesData = extractMergedImageData(doc);
  if (colorImagesData) {
    // 遍历所有颜色/变种的图片数据
    for (const [key, images] of Object.entries(colorImagesData)) {
      // 确保images是数组（防御性处理）
      if (!Array.isArray(images)) continue;

      // 处理图片数据，优先提取hiRes
      images.forEach((img) => {
        if (typeof img !== "object" || img === null) return;

        const hiResUrl = img.hiRes as string | undefined;
        const largeUrl = img.large as string | undefined;
        const imageUrl = hiResUrl || largeUrl;
        if (imageUrl) {
          const processedUrl = processImageUrl(imageUrl);
          // 去重处理：仅添加未出现过的有效URL
          if (processedUrl && !urls.includes(processedUrl)) {
            urls.push(processedUrl);
          }
        }
      });
    }
  }
  // const endTime = performance.now(); // 记录结束时间
  // const elapsedTime = (endTime - startTime) / 1000; // 转换为秒
  // console.info(
  //   `🖼️ 提取图片完成，共 ${urls.length} 张图片，耗时 ${elapsedTime.toFixed(
  //     2
  //   )} 秒`
  // );
  return urls;
}
// #endregion
// #region [主图]
// 假设存在图片URL处理工具函数（对应Python的process_image_url）
// 示例实现：可根据实际需求补充URL清理、域名转换等逻辑
/**
 * 处理图片URL，确保返回合适的图片格式（优先保留高清图）
 * @param url 原始图片URL
 * @returns 处理后的图片URL
 */
function processImageUrl(url: string): string {
  // 如果已经是高清图片（包含SL1500/SX1500/SY1500标识），直接返回
  if (
    url.includes("_SL1500_") ||
    url.includes("_SX1500_") ||
    url.includes("_SY1500_")
  ) {
    return url;
  }

  // 处理包含_AC_的图片URL，截取并保留AC标识
  if (url.includes("_AC_")) {
    const [prefix] = url.split("_AC_");
    return `${prefix}_AC_.jpg`;
  }

  // 其他情况直接返回原始URL
  return url;
}

/**
 * 从商品详情页提取主图URL（优先高清图）
 * @param doc 浏览器DOM Document对象
 * @returns 主图URL，未找到则返回空字符串
 */
export function extractMainImage(doc: Document): string {
  // 1. 查找主图容器（对应Python的find('div', class_='imgTagWrapper')）
  const mainImageDiv = doc.querySelector("div.imgTagWrapper");
  if (!mainImageDiv) return "";

  // 2. 查找容器内有src属性的img标签（对应Python的find('img', {'src': True})）
  const imgTag = mainImageDiv.querySelector("img[src]");
  if (!imgTag) return "";

  // 3. 优先取高清图URL（data-old-hires），无则取普通src（对应Python的get方法）
  const highResUrl = imgTag.getAttribute("data-old-hires");
  const srcUrl = imgTag.getAttribute("src") || "";
  const targetUrl = highResUrl || srcUrl;

  // 4. 处理URL（对应Python的process_image_url）并返回
  return processImageUrl(targetUrl);
}
// #endregion
